Kuinka voin poistaa tietyn kohteen taulukosta?

1
2
3
4
Seuraava
Etsi poistettavan taulukkoelementin hakemisto indexOf-toiminnolla ja poista sitten indeksi liitoksella.
Splice () -menetelmä muuttaa taulukon sisältöä poistamalla
olemassa olevia elementtejä ja / tai lisäämällä uusia elementtejä.
const-taulukko = [2, 5, 9];
console.log (taulukko);
const-indeksi = taulukko.indexOf (5);
jos (indeksi> -1) {
array.splice (hakemisto, 1);
}
// taulukko = [2, 9]
console.log (taulukko);
Toinen liitoksen parametri on poistettavien elementtien lukumäärä. Huomaa, että liitos muuttaa taulukkoa paikalleen ja palauttaa uuden taulukon, joka sisältää poistetut elementit.
Täydellisyyden vuoksi tässä on toimintoja. Ensimmäinen toiminto poistaa vain yhden esiintymän (eli poistaa ensimmäisen 5: n osuman kohdasta [2,5,9,1,5,8,5]), kun taas toinen toiminto poistaa kaikki esiintymät:
funktio removeItemOnce (arr, arvo) {
var-indeksi = arr.indexOf (arvo);
jos (indeksi> -1) {
arr.splice (hakemisto, 1);
}
paluu arr;
}
funktio removeItemAll (arr, arvo) {
var i = 0;
kun (i  = 0; i--) {
jos (taulukko [i] === numero) {
array.splice (i, 1);
}
}
Jos haluat vain, että elementti indeksissä i ei ole enää olemassa, mutta et halua muiden elementtien hakemistojen muuttuvan:
poista taulukko [i];
|
Muokattu 2016 lokakuussa
Tee se yksinkertaisesti, intuitiivisesti ja selkeästi (Occamin partaveitsi)
Tee se muuttumattomana (alkuperäinen taulukko pysyy muuttumattomana)
Tee se tavallisilla JavaScript-toiminnoilla, jos selaimesi ei tue niitä - käytä polyfill-tiedostoa
Tässä koodiesimerkissä käytän "array.filter (...)" -toimintoa poistamaan ei-toivotut kohteet taulukosta. Tämä toiminto ei muuta alkuperäistä taulukkoa ja luo uuden. Jos selaimesi ei tue tätä toimintoa (esim. Internet Explorer ennen versiota 9 tai Firefox ennen versiota 1.5), harkitse Mozillan suodattimen täyttöä.
Kohteen poistaminen (ECMA-262 Edition 5 -koodi eli oldstyle JavaScript)
var-arvo = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (funktio (kohde) {
return item! == arvo
})
console.log (arr)
// [1, 2, 4, 5]
Kohteen poistaminen (ECMAScript 6 -koodi)
anna arvon = 3
olkoon arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (kohde => kohde! == arvo)
console.log (arr)
// [1, 2, 4, 5]
TÄRKEÄÄ ECMAScript 6 "() => {}" nuolitoiminnon syntaksia ei tueta lainkaan Internet Explorer, Chrome ennen 45-versiota, Firefox ennen 22-versiota ja Safari ennen 10-versiota. Voit käyttää ECMAScript 6 -syntaksia vanhoissa selaimissa käyttämällä BabelJS: ää.
Useiden kohteiden poistaminen (ECMAScript 7 -koodi)
Tämän menetelmän lisäetuna on, että voit poistaa useita kohteita
anna forDeletion = [2, 3, 5]
olkoon arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item =>! forDeletion.includes (item))
// !!! Lue alla taulukosta. Sisältää (...) tuen !!!
console.log (arr)
// [1, 4]
TÄRKEÄÄ "array.includes (...)" -toimintoa ei tueta Internet Explorerissa, Chrome ennen 47-versiota, Firefox ennen 43-versiota, Safari ennen 9-versiota ja Edge ennen 14-versiota, joten tässä on Mozillan polyfill-täyttö.
Useiden kohteiden poistaminen (ehkä tulevaisuudessa)
Jos "Tämä sitova syntaksin" ehdotus hyväksytään koskaan, voit tehdä tämän:
// array-lib.js
vientitoiminto poista (... forDeletion) {
palauta tämä.suodatin (item =>! forDeletion.includes (item))
}
// main.js
tuo {poista} tiedostosta ./array-lib.js
olkoon arr = [1, 2, 3, 4, 5, 3]
// :: Tämä sitova syntaksiehdotus
// käyttämällä "poista" -toimintoa "virtuaalisena menetelmänä"
// laajentamatta Array.prototype
arr = arr :: poista (2, 3, 5)
console.log (arr)
// [1, 4]
Kokeile itse BabelJS: ssä :)
Viite
Taulukko.prototyyppi sisältää
Toiminnallinen koostumus
|
Se riippuu siitä, haluatko pitää tyhjän paikan vai ei.
Jos haluat tyhjän paikan:
taulukko [indeksi] = määrittelemätön;
Jos et halua tyhjää paikkaa:
// Alkuperäisen säilyttäminen:
// oldArray = [... taulukko];
// Tämä muuttaa taulukkoa.
array.splice (hakemisto, 1);
Ja jos tarvitset kyseisen kohteen arvoa, voit tallentaa palautetun taulukon elementin:
var-arvo = matriisi.splice (indeksi, 1) [0];
Jos haluat poistaa taulukon kummastakin päästä, voit käyttää array.pop () viimeistä tai array.shift () ensimmäistä (molemmat palauttavat myös kohteen arvon).
Jos et tiedä kohteen hakemistoa, voit käyttää sitä array.indexOf (item) -toiminnolla (if: ssä () saadaksesi yhden kohteen tai hetkessä () saadaksesi ne kaikki). array.indexOf (item) palauttaa joko indeksin tai -1, jos sitä ei löydy.
|
Ystävälläni oli ongelmia Internet Explorer 8: ssa ja näytti minulle, mitä hän teki. Sanoin hänelle, että se oli väärin, ja hän kertoi saaneen vastauksentässä. Nykyinen ylin vastaus ei toimi kaikissa selaimissa (esimerkiksi Internet Explorer 8), ja se poistaa vain kohteen ensimmäisen esiintymisen.
Poista KAIKKI esiintymät taulukosta
function array_remove_index_by_value (arr, kohde)
{
for (var i = arr.pituus; i--;)
{
if (arr [i] === kohde) {arr.splice (i, 1);}
}
}
Se silmukkaa taulukon läpi taaksepäin (koska indeksit ja pituus muuttuvat, kun kohteet poistetaan) ja poistaa kohteen, jos se löytyy. Se toimii kaikissa selaimissa.
|
On olemassa kaksi suurta lähestymistapaa:
liitos (): anArray.splice (hakemisto, 1);
poista: poista anArray [hakemisto];
Ole varovainen, kun käytät poistoa taulukossa. Se on hyvä esineiden määritteiden poistamiseen, mutta ei niin hyvä matriiseille. On parempi käyttää liitosta taulukoissa.
Muista, että kun käytät poistoa taulukossa, saatat saada vääriä tuloksia anArray.length. Toisin sanoen poisto poistaa elementin, mutta se ei päivitä pituusominaisuuden arvoa.
Voit myös odottaa aukkoja hakemistonumeroissa poiston käytön jälkeen, esim. indeksit 1, 3, 4, 8, 9 ja 11 ja pituus saattaisivat olla sellaisia ​​kuin ennen poiston käyttöä. Siinä tapauksessa kaikki silmukoita varten indeksoidut tiedot kaatuvat, koska indeksit eivät ole enää peräkkäisiä.
Jos sinun on pakko käyttää poistoa jostain syystä, sinun tulee käyttää jokaiselle silmukalle, kun sinun on silmukoitava taulukoiden läpi. Itse asiassa vältä aina indeksoitua käyttöä silmukoille, jos mahdollista. Tällä tavalla koodi olisi vankempi ja vähemmän altis ongelmille hakemistoissa.
|
Array.prototype.remove_by_value = funktio (val) {
for (var i = 0; i  rivi.id === 5);
var poistettu = auttaja.poista (arr, rivi => rivi.nimi.startsWith ('BMW'));
##Määritelmä
var auttaja = {
// Poista ja palauta ensimmäinen esiintymä
removeOne: funktio (matriisi, predikaatti) {
for (var i = 0; i  [2, 3, 4]
|
Voit käyttää ES6: ta. Esimerkiksi arvon 3 poistamiseksi tässä tapauksessa:
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((arvo) => arvo! = '3');
console.log (newArray);
Tuotos:
["1", "2", "4", "5", "6"]
|
Jos haluat uuden taulukon poistetuista paikoista, voit aina poistaa tietyn elementin ja suodattaa matriisin. Se saattaa tarvita taulukkoobjektin laajennuksen selaimille, jotka eivät ota käyttöön suodatusmenetelmää, mutta pitkällä aikavälillä se on helpompaa, koska kaikki mitä teet on tämä:
var my_ray = [1, 2, 3, 4, 5, 6];
poista my_array [4];
console.log (my_array.filter (funktio (a) {return typeof a! == 'undefined';}));
Sen pitäisi näyttää [1, 2, 3, 4, 6].
|
Tässä on muutama tapa poistaa kohde taulukosta JavaScriptin avulla.
Kaikki kuvatut menetelmät eivät muuta alkuperäistä taulukkoa, vaan luovat uuden.
Jos tiedät kohteen hakemiston
Oletetaan, että sinulla on taulukko ja haluat poistaa kohteen asemasta i.
Yksi menetelmä on käyttää slice ():
const kohteet = ['a', 'b', 'c', 'd', 'e', ​​'f']
const i = 3
const filteredItems = items.slice (0, i) .concat (items.slice (i + 1, items.length))
console.log (filteredItems)
slice () luo uuden taulukon vastaanotetuilla indekseillä. Luomme yksinkertaisesti uuden taulukon, alusta poistettavaan hakemistoon, ja ketjutamme toisen taulukon ensimmäisestä sijainnista poistamamme ryhmän jälkeen ryhmän loppuun.
Jos tiedät arvon
Tässä tapauksessa yksi hyvä vaihtoehto on käyttää suodatinta (), joka tarjoaa deklaratiivisemman lähestymistavan:
const kohteet = ['a', 'b', 'c', 'd', 'e', ​​'f']
const arvoToRemove = 'c'
const filteredItems = items.filter (item => item! == valueToRemove)
console.log (filteredItems)
Tämä käyttää ES6-nuolitoimintoja. Voit käyttää perinteisiä toimintoja vanhempien selainten tukemiseen:
const kohteet = ['a', 'b', 'c', 'd', 'e', ​​'f']
const arvoToRemove = 'c'
const filteredItems = items.filter (funktio (kohde) {
palauta kohde! == valueToRemove
})
console.log (filteredItems)
tai voit käyttää Babeliä ja siirtää ES6-koodin takaisin ES5: een, jotta se olisi paremmin sulavaa vanhoille selaimille, mutta voit kirjoittaa koodiin modernin JavaScriptin.
Useiden kohteiden poistaminen
Entä jos haluat poistaa yhden kohteen sijaan yhden kohteen?
Etsitään yksinkertaisin ratkaisu.
Hakemiston mukaan
Voit vain luoda toiminnon ja poistaa sarjassa olevia kohteita:
const kohteet = ['a', 'b', 'c', 'd', 'e', ​​'f']
const removeItem = (kohteet, i) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
anna filteredItems = removeItem (kohteet, 3)
filteredItems = removeItem (filteredItems, 5)
// ["a", "b", "c", "d"]
console.log (filteredItems)
Arvon mukaan
Voit etsiä sisällytystä takaisinsoittotoiminnosta:
const kohteet = ['a', 'b', 'c', 'd', 'e', ​​'f']
const arvotToRemove = ['c', 'd']
const filteredItems = items.filter (item =>! valuesToRemove.includes (item))
// ["a", "b", "e", "f"]
console.log (filteredItems)
Vältä alkuperäisen taulukon mutaatiota
liitos () (ei pidä sekoittaa viipaleeseen ()) mutatoi alkuperäisen taulukon, ja sitä tulisi välttää.
(lähetetty alun perin sivustolleni https://flaviocopes.com/how-to-remove-item-from-array/)
|
Tarkista tämä koodi. Se toimii jokaisessa suuressa selaimessa.
remove_item = funktio (arr, arvo) {
var b = '';
varten (b sisään arr)
jos (arr [b] === arvo) {
arr. liitos (b, 1);
tauko;
}
}
paluu arr;
};
Kutsu tätä toimintoa
remove_item (taulukko, arvo);
|
ES6 ja ilman mutaatiota: (lokakuu 2016)
const removeByIndex = (luettelo, hakemisto) =>
[
... list.slice (0, hakemisto),
... list.slice (hakemisto + 1)
];
output = poistaByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (lähtö)
|
Voit käyttää lodashia _.pull (mutaatiotaulukko), _.pullAt (mutaatiotaulukko) tai _.
var array1 = ['a', 'b', 'c', 'd']
_.pull (taulukko1, 'c')
console.log (array1) // ['a', 'b', 'd']
var array2 = ['e', 'f', 'g', 'h']
_.pullAt (taulukko2, 0)
console.log (array2) // ['f', 'g', 'h']
var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without (taulukko3, 'i') // ['j', 'k', 'l']
console.log (array3) // ['i', 'j', 'k', 'l']
|
Tietyn elementin / merkkijonon poistaminen taulukosta voidaan tehdä yksirivisellä:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
missä:
theArray: taulukko, josta haluat poistaa jotain tiettyä
stringToRemoveFromArray: poistettava merkkijono ja 1 on poistettavien elementtien määrä.
HUOMAUTUS: Jos "stringToRemoveFromArray" ei sijaitse taulukossasi, se poistaa matriisin viimeisen elementin.
Se on aina hyvä tapa tarkistaa, onko elementti ryhmässäsi ennen sen poistamista.
if (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}
Jos sinulla on pääsy uudempiin Ecmascript-versioihin asiakkaasi tietokoneissa (VAROITUS, ei välttämättä toimi vanhemmilla asemilla):
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((arvo) => arvo! = '3');
Missä '3' on arvo, jonka haluat poistaa taulukosta.
Taulukosta tulisi sitten: ['1', '2', '4', '5', '6']
|
OK, esimerkiksi sinulla on alla oleva taulukko:
var num = [1, 2, 3, 4, 5];
Ja haluamme poistaa numeron 4. Voit käyttää yksinkertaisesti alla olevaa koodia:
num.splice (num.indexOf (4), 1); // numero on [1, 2, 3, 5];
Jos käytät tätä toimintoa uudelleen, kirjoitat uudelleenkäytettävän toiminnon, joka liitetään natiiviryhmätoimintoon kuten alla:
Array.prototype.remove = Array.prototype.remove || funktio (x) {
const i = tämä.indexOf (x);
jos (i === - 1)
palata;
tämä. osa (i, 1); // lukumäärä poista (5) === [1, 2, 3];
}
Mutta entä jos sinulla on alla oleva taulukko ja muutama [5] s taulukossa?
var num = [5, 6, 5, 4, 5, 1, 5];
Tarvitsemme silmukan kaikkien tarkistamiseksi, mutta helpompi ja tehokkaampi tapa on käyttää sisäänrakennettuja JavaScript-toimintoja, joten kirjoitamme funktion, joka käyttää sen sijaan alla olevaa suodatinta:
const _removeValue = (arr, x) => arr.suodatin (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // Paluu [1, 2, 3, 4, 6]
Lisäksi on olemassa kolmannen osapuolen kirjastoja, jotka auttavat sinua tekemään tämän, kuten Lodash tai Alaviiva. Lisätietoja on osoitteissa lodash _.pull, _.pullAt tai _.withing.
|
Esitys
Tänään (2019-12-09) suoritan suorituskykytestit macOS v10.13.6 (High Sierra) -palvelussa valituille ratkaisuille. Näytän poistaa (A), mutta en käytä sitä muihin menetelmiin verrattuna, koska se jätti matriisiin tyhjää tilaa.
Päätelmät
nopein ratkaisu on array.splice (C) (paitsi Safari pienille matriiseille, joissa sillä on toinen kerta)
isoille matriiseille array.slice + splice (H) on nopein muuttumaton ratkaisu Firefoxille ja Safarille; Array.from (B) on nopein Chromessa
muutettavissa olevat liuokset ovat yleensä 1,5x-6x nopeampi kuin muuttumattomia
Safarin pienissä pöydissä on yllättäen muutettava liuos (C) hitaampi kuin muuttumaton liuos (G)
Yksityiskohdat
Testeissä poistan matriisista keskielementin eri tavoin. A, C-ratkaisut ovat paikallaan. B-, D-, E-, F-, G-, H-liuokset ovat muuttumattomia.
Tulokset ryhmälle, jossa on 10 elementtiä
Chromessa array.splice (C) on nopein paikan päällä oleva ratkaisu. Array.filter (D) on nopein muuttumaton ratkaisu. Hitain on array.slice (F). Voit suorittaa testin koneellasi täällä.
Tulokset ryhmälle 1.000.000 elementtiä
Chromessa array.splice (C) on nopein paikan päällä oleva ratkaisu (poisto (C) on samanlainen nopeasti - mutta se jätti matriisiin tyhjän paikan (joten se ei suorita täydellistä poistoa)). Array.slice-splice (H) on nopein muuttumaton ratkaisu. Hitain on array.filter (D ja E). Voit suorittaa testin koneellasi täällä.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (kirjain, taulukko) => konsoli.log (kirjain, taulukko.liitä `,`);
funktio A (matriisi) {
var-indeksi = taulukko.indexOf (5);
poista taulukko [hakemisto];
loki ('A', taulukko);
}
funktio B (matriisi) {
var-indeksi = taulukko.indexOf (5);
var arr = Array.from (taulukko);
arr.splice (hakemisto, 1)
loki ('B', arr);
}
funktio C (matriisi) {
var-indeksi = taulukko.indexOf (5);
array.splice (hakemisto, 1);
loki ('C', taulukko);
}
funktio D (matriisi) {
var arr = array.filter (kohde => kohde! == 5)
loki ('D', arr);
}
funktio E (matriisi) {
var-indeksi = taulukko.indexOf (5);
var arr = array.filter ((kohde, i) => i! == hakemisto)
loki ('E', arr);
}
funktio F (matriisi) {
var-indeksi = taulukko.indexOf (5);
var arr = array.slice (0, hakemisto) .concat (array.slice (indeksi + 1))
loki ('F', arr);
}
funktio G (matriisi) {
var-indeksi = taulukko.indexOf (5);
var arr = [... array.slice (0, hakemisto), ... array.slice (indeksi + 1)]
loki ('G', arr);
}
funktio H (matriisi) {
var-indeksi = taulukko.indexOf (5);
var arr = matriisi.leike (0);
arr.splice (hakemisto, 1);
loki ('H', arr);
}
A ([... a]);
B ([... a]);
C ([... a]);
D ([... a]);
E ([... a]);
Fa]);
G ([... a]);
H ([... a]);
Tämä katkelma esittää vain suorituskykytesteissä käytetyn koodin - se ei tee itse testejä.
Vertailu selaimille: Chrome v78.0.0, Safari v13.0.4 ja Firefox v71.0.0
|
Olen melko uusi JavaScript ja tarvitsin tätä toimintoa. Kirjoitin vain tämän:
funktio removeFromArray (taulukko, kohde, hakemisto) {
while ((index = taulukko.indexOf (kohde))> -1) {
array.splice (hakemisto, 1);
}
}
Sitten kun haluan käyttää sitä:
// Määritä joitain nuken tietoja
var dummyObj = {nimi: "miau"};
var dummyArray = [dummyObj, "kohde1", "kohde1", "kohde2"];
// Poista nuken tiedot
removeFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, "item2");
Tuotos - odotetusti.
["item1", "item1"]
Sinulla voi olla erilaisia ​​tarpeita kuin minä, joten voit helposti muokata sitäsopivaksi heille. Toivon, että tämä auttaa jotakuta.
|
Jos taulukossa on monimutkaisia ​​objekteja, voit käyttää suodattimia?
Tilanteissa, joissa $ .inArray tai array.splice ei ole yhtä helppoa käyttää. Varsinkin jos objektit ovat kenties matalia matriisissa.
Esim. jos sinulla on objekti, jolla on Id-kenttä, ja haluat objektin poistettavan taulukosta:
this.array = this.ray.filter (funktio (elementti, i) {
return element.id! == idToRemove;
});
|
Haluan vastata ECMAScript 6: n perusteella. Oletetaan, että sinulla on alla oleva taulukko:
olkoon arr = [1,2,3,4];
Jos haluat poistaa erityisen hakemiston, kuten 2, kirjoita alla oleva koodi:
arr. liitos (2, 1); // => arr: sta tuli [1,2,4]
Mutta jos haluat poistaa erityisen kohteen, kuten 3, etkä tiedä sen hakemistoa, tee kuten alla:
arr = arr.suodatin (e => e! == 3); // => arr: sta tuli [1,2,4]
Vinkki: Käytä nuolitoimintoa suodatettaessa takaisinsoittoa, ellet saa tyhjää taulukkoa.
|
Päivitys: Tätä menetelmää suositellaan vain, jos et voi käyttää ECMAScript 2015: ää (tunnettiin aiemmin nimellä ES6). Jos voit käyttää sitä, muut vastaukset tarjoavat paljon siistimpiä toteutuksia.
Tämä ydin ratkaisee ongelmasi ja poistaa myös kaikki argumentin esiintymät vain yhden (tai määritetyn arvon) sijaan.
Array.prototype.destroy = funktio (obj) {
// Palauta null, jos mitään esineitä ei löydy tai poistettu
var tuhottu = tyhjä;
for (var i = 0; i  3
x. tuhota (väärä); // => väärä
x; // => [1, 2, tosi, määrittelemätön]
x. tuhota (true); // => totta
x. tuhota (määrittelemätön); // => undefined
x; // => [1, 2]
x. tuhota (3); // => tyhjä
x; // => [1, 2]
|
ES10-päivitys
Tämä viesti tiivistää yleiset lähestymistavat elementtien poistamiseen matriisista ECMAScript 2019: n (ES10) mukaisesti.
1. Yleiset tapaukset
1.1. Taulukkoelementin poistaminen arvolla käyttämällä .splice ()
| Paikalla: Kyllä |
| Poistaa kaksoiskappaleet: Kyllä (silmukka), Ei (indexOf) |
| Arvon / indeksin mukaan: indeksin mukaan |
Jos tiedät arvon, jonka haluat poistaa taulukosta, voit käyttää liitosmenetelmää. Ensin sinun on tunnistettava kohdekohteen hakemisto. Sitten käytät hakemistoa alkuelementtinä ja poistat vain yhden elementin.
// 'for' -silmukalla
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for (olkoon i = 0; i  [1, 2, 3, 4, 6, 7, 8, 9, 0]
// .indexOf () -menetelmällä
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf (5);
arr. liitos (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. Array-elementin poistaminen .filter () -menetelmällä
| Paikalla: Ei |
| Poistaa kaksoiskappaleet: Kyllä |
| Arvon / indeksin mukaan: arvon mukaan
Tietty elementti voidaan suodattaa pois taulukosta tarjoamalla suodatustoiminto. Tällaista toimintoa kutsutaan sitten jokaiselle matriisin elementille.
const-arvo = 3
olkoon arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (kohde => kohde! == arvo)
console.log (arr)
// [1, 2, 4, 5]
1.3. Array-elementin poistaminen laajentamalla Array.prototype
| Paikalla: Kyllä / Ei (riippuu toteutuksesta) |
| Poistaa kaksoiskappaleet: Kyllä / Ei (riippuu toteutuksesta) |
| Arvon / indeksin mukaan: indeksin / arvon mukaan (riippuu toteutuksesta) |
Array-prototyyppiä voidaan laajentaa lisämenetelmillä. Tällaisia ​​menetelmiä voidaan sitten käyttää luotuihin matriiseihin.
Huomaa: Jotkut pitävät objektien prototyyppien laajentamista JavaScriptin tavallisesta kirjastosta (kuten Array) anti-mallina.
// Paikalla, poistaa kaikki arvototeutuksella
Array.prototype.remove = funktio (kohde) {
for (olkoon i = 0; i  = ES10)
| Paikalla: Ei |
| Poistaa kaksoiskappaleet: Kyllä |
| Arvon / indeksin mukaan: arvon mukaan |
ES10 esitteli Object.fromEntries, joka voi ollakäytetään luomaan haluttu taulukko mistä tahansa matriisin kaltaisesta kohteesta ja suodattamaan ei-toivotut elementit prosessin aikana.
const-objekti = [1,2,3,4];
const arvoToRemove = 3;
const arr = Object.values ​​(Object.fromEntries (
Object.entries (objekti)
.filter (([avain, val]) => val! == valueToRemove)
));
console.log (arr); // [1,2,4]
2. Erityistapaukset
2.1 Elementin poistaminen, jos se on taulukon lopussa
2.1.1. Matriisin pituuden muuttaminen
| Paikalla: Kyllä |
| Poistaa kaksoiskappaleet: Ei |
| Arvon / indeksin mukaan: N / A |
JavaScript-matriisin elementit voidaan poistaa matriisin päästä asettamalla pituusominaisuudeksi nykyistä arvoa pienempi arvo. Kaikki elementit, joiden indeksi on suurempi tai yhtä suuri kuin uusi pituus, poistetaan.
const arr = [1, 2, 3, 4, 5, 6];
arr.pituus = 5; // Aseta pituus elementin poistamiseksi
console.log (arr); // [1, 2, 3, 4, 5]
2.1.2. Käyttämällä .pop () -menetelmää
| Paikalla: Kyllä |
| Poistaa kaksoiskappaleet: Ei |
| Arvon / indeksin mukaan: N / A |
Pop-menetelmä poistaa matriisin viimeisen elementin, palauttaa kyseisen elementin ja päivittää pituusominaisuuden. Pop-menetelmä muuttaa taulukkoa, johon sitä kutsutaan. Tämä tarkoittaa, toisin kuin poisto-toiminnolla, viimeinen elementti poistetaan kokonaan ja matriisin pituus pienenee.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // palauttaa 6
console.log (arr); // [1, 2, 3, 4, 5]
2.2. Elementin poistaminen, jos se on taulukon alussa
| Paikalla: Kyllä |
| Poistaa kaksoiskappaleet: Ei |
| Arvon / indeksin mukaan: N / A |
.Shift () -menetelmä toimii aivan kuten pop-menetelmä, paitsi että se poistaa JavaScript-taulukon ensimmäisen elementin viimeisen sijaan. Kun elementti poistetaan, muut elementit siirretään alaspäin.
const arr = [1, 2, 3, 4];
arr.vaihto (); // palauttaa arvon 1
console.log (arr); // [2, 3, 4]
2.3. Elementin poistaminen, jos se on matriisin ainoa elementti
| Paikalla: Kyllä |
| Poistaa kaksoiskappaleet: N / A |
| Arvon / indeksin mukaan: N / A |
Nopein tekniikka on asettaa matriisimuuttuja tyhjäksi.
anna arr = [1];
arr = []; // tyhjä taulukko
Vaihtoehtoisesti voidaan käyttää 2.1.1-tekniikkaa asettamalla pituus 0: ksi.
|
Sinun ei pitäisi koskaan mutatoida taulukkoasi. Koska tämä on toiminnallisen ohjelmointikuvion vastaista. Voit luoda uuden taulukon viittaamatta taulukkoon, jonka tietoja haluat muuttaa, käyttämällä ECMAScript 6 -menetelmän suodatinta;
var myArray = [1, 2, 3, 4, 5, 6];
Oletetaan, että haluat poistaa 5 ryhmästä, voit tehdä sen näin:
myArray = myArray.filter (arvo => arvo! == 5);
Tämä antaa sinulle uuden taulukon ilman arvoa, jonka haluat poistaa. Joten tulos on:
[1, 2, 3, 4, 6]; // 5 on poistettu tästä taulukosta
Lisätietojen saamiseksi voit lukea MDN-ohjeet Array.filter-sivustolta.
|
Nykyaikaisempi lähestymistapa ECMAScript 2015 (aiemmin tunnettu nimellä Harmony tai ES 6). Annettu:
konttikohdat = [1, 2, 3, 4];
const-indeksi = 2;
Sitten:
items.filter ((x, i) => i! == hakemisto);
Tuotto:
[1, 2, 4]
Voit käyttää Babelia ja polyfill-palvelua varmistaaksesi, että tätä tuetaan hyvin kaikissa selaimissa.
|
Voit tehdä taaksepäin silmukan varmistaaksesi, ettet ruuvaa hakemistoja, jos elementillä on useita esiintymiä.
var myElement = "suklaa";
var myArray = ['suklaa', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];
/ * Tärkeä koodi * /
for (var i = myArray.length - 1; i> = 0; i--) {
if (myArray [i] == myElement) myArray.splice (i, 1);
}
console.log (myArray);
Live-esittely
|
Matriisissa on 1–9 ja haluat poistaa 5. Käytä seuraavaa koodia:
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
paluu m! = = 5;
});
console.log ("uusi taulukko, 5 poistettu", newNumberArray);
Jos haluat useita arvoja. Esimerkki: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
paluu (m! == 1) && (m! == 7) && (m! == 8);
});
console.log ("uusi taulukko, 1,7 ja 8 poistettu", newNumberArray);
Jos haluat poistaa taulukon matriisin arvon. Esimerkki: [3,4,5]
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];
var newNumberArray = numberArray.filter (m => {
return! removebleArray. sisältää (m);
});
console.log ("uusi taulukko, [3,4,5] poistettu", newNumberArray);
Sisältää tuetun selaimen linkin.
|
1
2
3
4
Seuraava
Erittäin aktiivinen kysymys. Ansaitse 10 mainetta vastaamiseksi tähän kysymykseen. Maineen vaatimus auttaa suojaamaan tätä kysymystä roskapostilta ja vastaamattomuudelta.
Eikö vastausta etsit? Selaa muita kysymyksiä, jotka on merkitty javascript-matriiseilla, tai kysy omia kysymyksiä.